package main

import "fmt"

// 假设我们要让程序按照指定的步骤执行，并且这个步骤的顺序不是固定的，
// 而是可以根据不同需求改变的，每个步骤都会对请求进行一些处理，
// 并将结果传递给下一个步骤的处理者，就像一条流水线一样，我们该如何实现？
// 当遇到这种必须按顺序执行多个处理者，并且处理者的顺序可以改变的需求，我们可以考虑使用责任链模式

type department interface {
	execute(*Do)
	setNext(department)
}
type aPart struct {
	next department
}

func (r *aPart) execute(p *Do) {
	if p.aPartDone {
		fmt.Println("aPart done")
		r.next.execute(p)
		return
	}
	fmt.Println("aPart")
	p.aPartDone = true
	r.next.execute(p)
}
func (r *aPart) setNext(next department) {
	r.next = next
}

type bPart struct {
	next department
}

func (d *bPart) execute(p *Do) {
	if p.bPartDone {
		fmt.Println("bPart done")
		d.next.execute(p)
		return
	}
	fmt.Println("bPart")
	p.bPartDone = true
	d.next.execute(p)
}
func (d *bPart) setNext(next department) {
	d.next = next
}

type endPart struct {
	next department
}

func (c *endPart) execute(p *Do) {
	if p.endPartDone {
		fmt.Println("endPart Done")
	}
	fmt.Println("endPart")
}
func (c *endPart) setNext(next department) {
	c.next = next
}

type Do struct {
	aPartDone   bool
	bPartDone   bool
	endPartDone bool
}

func ExampleChain() {
	startPart := &endPart{}

	aPart := &aPart{}
	aPart.setNext(startPart)

	bPart := &bPart{}
	bPart.setNext(aPart)

	do := &Do{}
	bPart.execute(do)
}
